import Vue from 'vue'
import Vuex from 'vuex'

// 引入 api 模块
import { getQuestionBankList,softDeleteQuestionBank, getQuestionsByBank, updateQuestion, softDeleteQuestion } from '@/api/question'

import { formatCorrectAnswer } from '@/utils/format'


Vue.use(Vuex)



export default {
    state: {
        // ================= 题库列表管理 =================
        banks: [], // 所有题库数据数组
        currentBank: null, // 当前选中的题库对象（BankCard组件点击时设置）
        searchQuery: '', // 题库搜索关键词
        regeneratedQuestion: null, // 存储重新生成的题目
        pagination: { // 分页控制
            currentPage: 1, // 当前页码
            pageSize: 10,  // 每页显示数量
            totalItems: 0,   // 总条目数（需在获取数据后更新）
            hasMoreData: true, // 是否还有更多数据
            bankName: '', // 题库名称（用于搜索）
        },
        loading: false,  // 全局加载状态

        // ================= 题目管理 =================
        questions: [],    // 当前题库下的题目列表
        currentQuestion: null, // 当前操作的题目对象
        activeQuestions: [], // 当前展开的题目索引数组
        allExpanded: false, // 是否全部展开
        questionPagination: { // 题目分页控制
            currentPage: 1, // 当前页码
            pageSize: 10, // 每页显示数量
            totalItems: 0 // 总条目数（需在获取数据后更新）
        },
        questionLoading: false, // 题目加载状态,

        // ================= 弹窗状态管理 =================
        dialogs: {
            // 题库操作弹窗（合并create/edit）
            bankDialog: {
                visible: false,   // 显示状态
                mode: 'create',   // 模式：create/edit
                bankData: {       // 表单数据（修正原代码拼写 bankDate -> bankData）
                    name: '',        // 题库名称
                    description: ''  // 题库描述
                }
            },

            // 删除确认弹窗（独立出来更清晰）
            deleteConfirm: {
                visible: false,
                title: '确认删除',
                message: '确定要删除这个题库吗？删除后无法恢复！',
                confirmText: '删除',
                cancelText: '取消',
                type: 'danger',    // 控制按钮颜色样式
                target: null       // 要删除的对象引用
            },

            // AI题目生成器
            aiGenerator: {
                visible: false,
                generating: false, // 是否正在生成中
                progress: 0,      // 生成进度百分比
                generatedQuestions: [] // 已生成的题目列表
            },

            // 题目编辑弹窗
            questionEdit: {
                visible: false,
                question: null    // 正在编辑的题目对象
            }
        },
        
        // ================= 题库选择配置 =================
        bankSelectionConfig: null, // 保存题库选择模态框的配置信息
    },
    getters: {
        // 题库相关
        filteredBanks: state => {
            // 如果搜索关键词为空，则返回所有题库
            if (!state.searchQuery) return state.banks

            // 否则，返回匹配搜索关键词的题库
            return state.banks.filter(bank =>
                bank.bankName.toLowerCase().includes(state.searchQuery.toLowerCase()) ||
                (bank.description && bank.description.toLowerCase().includes(state.searchQuery.toLowerCase()))
            );
        },

        paginateBanks: (state, getters) => {
            // 获取当前页的题库数据
            const start = (state.pagination.currentPage - 1) * state.pagination.pageSize;
            const end = start + state.pagination.pageSize;
            return getters.filteredBanks.slice(start, end);
        },
        getPagination:(state) => {
            // 返回当前的分页信息
            return {
                currentPage: state.pagination.currentPage,
                pageSize: state.pagination.pageSize,
                totalItems: state.pagination.totalItems,
                hasMoreData: state.pagination.hasMoreData,
                bankName: state.pagination.bankName
            }
        },
        // 获取所有的题库
        banks: state => state.banks,
        /************************题目相关**********************/
        /**
         * 获取当前题库的题目列表
         * @param {Object} state - Vuex状态对象
         * @returns {Array} 题目列表
         */
        questions: state => state.questions,

        /**
         * 获取当前操作的题目对象
         * @param {Object} state - Vuex状态对象
         * @returns {Object} 当前操作的题目对象
         */
        currentQuestion: state => state.currentQuestion,


        /**
         * 获取分页后的题目列表
         * @param {Object} state - Vuex状态对象
         * @param {Object} getters - Vuex getters对象
         * @returns {Array} 分页后的题目列表
         */
        paginatedQuestions: (state, getters) => {
            const start = (state.questionPagination.currentPage - 1) * state.questionPagination.pageSize;
            const end = start + state.questionPagination.pageSize;
            return state.questions.slice(start, end);
        },

        /**
         * 获取当前展开的题目索引数组
         * @param {Object} state - Vuex状态对象
         * @returns {Array} 当前展开的题目索引数组
         */
        activeQuestions: state => state.activeQuestions,

        /**
         * 获取是否全部展开
         * @param {Object} state - Vuex状态对象
         * @returns {Boolean} 是否全部展开
         */
        allExpanded: state => state.allExpanded,

    },
    mutations: {
        /************************题库相关**********************/

        setBanks(state, banks) {
            state.banks = banks
        },

        setPagination(state, pagination) {
            // 更新题库分页信息
            state.pagination = {
                ...state.pagination,
                ...pagination
            }
        },
        /**
         * 设置题库列表和总项数
         * @param {Object} state - Vuex状态对象
         * @param {Array} banks - 银行列表数组
         */
        SET_BANKS(state, payload) {
            state.banks = payload.banks
            state.pagination.totalItems = payload.totalItems
        },

        /**
         * 追加题库数据
         * @param {Object} state - Vuex状态对象
         * @param {Object} payload - 包含banks和totalItems的对象
         */
        APPEND_BANKS(state, payload) {
            // 过滤掉已有的题库（根据bankId）
            const newBanks = payload.banks.filter(newBank => 
                !state.banks.some(existingBank => existingBank.bankId === newBank.bankId)
            );
            
            // 追加新题库到现有数组
            state.banks = [...state.banks, ...newBanks];
            
            // 更新总数
            if (payload.totalItems > state.pagination.totalItems) {
                state.pagination.totalItems = payload.totalItems;
            }
        },

        /**
         * 设置当前选中的题库
         * @param {Object} state - Vuex状态对象
         * @param {Object} bank - 当前选中的银行对象
         */
        SET_CURRENT_BANK(state, bank) {
            state.currentBank = bank
        },

        /**
         * 设置搜索查询字符串
         * @param {Object} state - Vuex状态对象
         * @param {String} query - 搜索查询字符串
         */
        SET_SEARCH_QUERY(state, query) {
            state.searchQuery = query
        },

        /**
         * 设置分页信息
         * @param {Object} state - Vuex状态对象
         * @param {number} currentPage - 当前页码
         * @param {number} pageSize - 每页大小
         */
        SET_PAGINATION(state, payload) {
            state.pagination = {
                ...state.pagination,
                ...payload
            };
        },

        /**
         * 设置加载状态
         * @param {Object} state - Vuex状态对象
         * @param {boolean} loading - 加载状态布尔值
         */
        SET_LOADING(state, loading) {
            state.loading = loading
        },

        /**
         * 从题库列表中移除指定ID的题库
         * @param {Object} state - Vuex状态对象
         * @param {number} bankId - 要删除的题库ID
         */
        REMOVE_BANK(state, bankId) {
            // 从题库列表中移除指定ID的题库
            state.banks = state.banks.filter(bank => bank.bankId !== bankId)
        },

        /**
         * 添加新题库到题库列表
         * @param {Object} state - Vuex状态对象
         * @param {Object} bank - 新题库对象
         */
        ADD_BANK(state, bank) {
            // console.log("ADD_BANK 被调用，题库:", bank);
            
            // 确保totalQuestionNum字段是数字类型
            if (bank.totalQuestionNum !== undefined) {
                bank.totalQuestionNum = parseInt(bank.totalQuestionNum, 10) || 0;
            } else {
                bank.totalQuestionNum = 0;
            }
            
            // console.log("ADD_BANK 处理后题目数量:", bank.totalQuestionNum);

            // 检查题库是否已存在
            const existingIndex = state.banks.findIndex(b => b.bankId === bank.bankId);
            if (existingIndex === -1) {
                // 添加新题库到列表第一个
                state.banks.unshift(bank);
                // 更新总数
                state.pagination.totalItems++;
            } else {
                // 更新现有题库（不累加题目数量，只使用传入的数量）
                Vue.set(state.banks, existingIndex, bank);
            }
        },

        /************************弹窗相关**********************/
        /**
         * 显示删除确认弹窗
         * @param {Object} state - Vuex状态对象
         * @param {Object} payload - 弹窗配置
         * @param {string} payload.title - 弹窗标题
         * @param {string} payload.message - 确认消息
         * @param {Object} payload.target - 要删除的目标对象
         */
        SHOW_DELETE_CONFIRM(state, {title, message, target}) {
            state.dialogs.deleteConfirm = {
                visible: true,
                title: title || '确认删除',
                message: message || '确定要删除这个题库吗？删除后无法恢复！',
                confirmText: '删除',
                cancelText: '取消',
                type: 'danger',
                target: target
            }
        },

        /**
         * 隐藏删除确认弹窗
         * @param {Object} state - Vuex状态对象
         */
        HIDE_DELETE_CONFIRM(state) {
            state.dialogs.deleteConfirm.visible = false
            state.dialogs.deleteConfirm.target = null
        },

        /************************题目相关**********************/
        /**
         * 设置题目列表和总项数
         * @param {Object} state - Vuex状态对象
         * @param {Array} questions - 题目列表数组
         * @param {number} totalItems - 总项数
         */
        SET_QUESTIONS(state, payload) {
            // 设置题目列表和分页信息
            state.questions = payload.questions;
            state.questionPagination.totalItems = payload.totalItems;
            
            // 完全禁止在SET_QUESTIONS中更新题库数量，避免重复计数
            // 题库数量只应该在ADD_BANK时设置一次
            
            // 如果传入了bankId，警告一下，因为这可能导致题目数量计算问题
            if (payload.bankId) {
                // console.warn('警告：SET_QUESTIONS被调用时包含bankId参数，这可能导致题目数量重复计数问题');
                // console.warn('请修改调用代码，不要传递bankId参数');
                
                // 确保不会使用bankId去更新题库数量
            }
        },

        /**
         * 设置当前选中的题目
         * @param {Object} state - Vuex状态对象
         * @param {Object} question - 当前选中的题目对象
         */
        SET_CURRENT_QUESTION(state, question) {
            state.currentQuestion = question
        },

        /**
         * 添加新题目到题目列表
         * @param {Object} state - Vuex状态对象
         * @param {Object} question - 新题目对象
         */
        ADD_QUESTION(state, question) {
            state.questions.unshift(question);
            state.questionPagination.totalItems++;
            // 禁止在ADD_QUESTION中更新题库数量，避免重复计数
            // 题库数量只应在创建题库时设置一次
        },

        /**
         * 更新题目列表中的指定索引的题目
         * @param {Object} state - Vuex状态对象
         * @param {Object} payload - 更新参数
         * @param {number} payload.index - 要更新的题目索引
         * @param {Object} payload.question - 更新的题目对象
         */
        UPDATE_QUESTION(state, {index, question}) {
            // 使用 Vue.set 确保响应式更新
            Vue.set(state.questions, index, question);

            // 如果当前题目是展开状态，保持其展开状态
            const wasActive = state.activeQuestions.includes(index);
            if (wasActive) {
                const idx = state.activeQuestions.indexOf(index);
                state.activeQuestions.splice(idx, 1);
                state.activeQuestions.push(index);
            }
        },

        /**
         * 从题目列表中删除指定索引的题目
         * @param {Object} state - Vuex状态对象
         * @param {number} index - 要删除的题目索引
         */
        DELETE_QUESTION(state, questionId) {
            const index = state.questions.findIndex(q => q.questionId === questionId);
            if (index !== -1) {
                state.questions.splice(index, 1);
            }
        },

        /**
         * 设置题目分页信息
         * @param {Object} state - Vuex状态对象
         * @param {Object} payload - 分页信息对象
         */
        SET_QUESTION_PAGINATION(state, payload) {
            state.questionPagination = { // 修正拼写
                ...state.questionPagination,
                ...payload
            }
        },

        /**
         * 设置题目加载状态
         * @param {Object} state - Vuex状态对象
         * @param {boolean} loading - 加载状态布尔值
         */
        SET_QUESTION_LOADING(state, loading) {
            state.questionLoading = loading
        },

        /**
         * 切换题目的展开状态
         * @param {Object} state - Vuex状态对象
         * @param {Number} idnex - 题目的索引
         */
        TOGGLE_QUESTION_EXPAND(state, index) {
            const idx = state.activeQuestions.indexOf(index)
            if (idx > -1 ) {
                state.activeQuestions.splice(idx, 1)
            } else {
                state.activeQuestions.push(index)
            }
            // 更新全部展开状态
            state.allExpanded = state.activeQuestions.length === state.questions.length
        },

        /**
         * 切换所有题目的展开状态
         * @param {Object} state - Vuex状态对象
         */
        TOGGLE_ALL_QUESTIONS_EXPAND(state) {
            state.allExpanded = !state.allExpanded
            if (state.allExpanded) {
                state.activeQuestions = state.questions.map((_, index) => index)
            } else {
                state.activeQuestions = []
            }
        },
        /**
         * 设置当前正在编辑的题目
         * @param {Object} state - Vuex状态对象
         * @param {Object} question - 当前正在编辑的题目对象
         */
        SET_CURRENT_EDITING_QUESTION(state, question) {
            state.dialogs.questionEdit.question = question
        },

        DECREMENT_BANK_QUESTION_COUNT(state, bankId) {
            // 这个方法仍然需要保留，用于删除题目时更新题库数量
            const bank = state.banks.find(b => b.bankId === bankId);
            if (bank) {
                bank.totalQuestionNum = Math.max(0, bank.totalQuestionNum - 1);
            }
        },

        /**
         * 增加题库题目数量
         * @param {Object} state - Vuex状态对象
         * @param {number} bankId - 题库ID
         */
        INCREMENT_BANK_QUESTION_COUNT(state, bankId) {
            const bank = state.banks.find(b => b.bankId === bankId);
            if (bank) {
                bank.totalQuestionNum = (bank.totalQuestionNum || 0) + 1;
            }
        },

        // 保存题库选择配置
        SAVE_BANK_SELECTION_CONFIG(state, config) {
            state.bankSelectionConfig = config
        },
        
        // 设置生成的题目
        SET_GENERATED_QUESTIONS(state, questions) {
            state.dialogs.aiGenerator.generatedQuestions = questions
        },
        
        // 设置当前题库的题目列表
        SET_CURRENT_BANK_QUESTIONS(state, questions) {
            state.questions = questions
        },
        
        // 减少题库题目计数
        // 更新重新生成的题目
        UPDATE_REGENERATED_QUESTION(state, question) {
            state.regeneratedQuestion = question;
        },
    },
    actions: {
        /************************题库相关**********************/
        /**
         * 获取题库列表
         * @param {Object} commit - Vuex commit函数
         * @param {Object} state - Vuex状态对象
         * @returns {Promise<void>}
         */
        async fetchBanks({commit, state: {pagination}}) {
            commit('SET_LOADING', true)
            try {
                // 从API获取题库列表
                const { currentPage, pageSize, bankName } = pagination;

                // console.log("正在获取题库列表, 页码:", currentPage, "每页数量:", pageSize, "搜索关键词:", bankName.trim());
                
                const response = await getQuestionBankList({
                    page: currentPage,
                    pageSize: pageSize,
                    bankName: bankName.trim() // 确保搜索关键词是去除空格的
                })
                
                // 更新题库列表和总数
                const banks = response?.data?.data?.rows || [];
                const totalItems = response?.data?.data?.total || 0;
                
                // 如果是第一页，则替换所有数据
                if (currentPage === 1) {
                    commit('SET_BANKS', { banks, totalItems });
                } else {
                    // 否则追加数据
                    commit('APPEND_BANKS', { banks, totalItems });
                }
                
                // 更新是否还有更多数据
                const hasMoreData = banks.length === pageSize && (currentPage * pageSize) < totalItems;
                commit('SET_PAGINATION', { hasMoreData });
                
                // console.log('题库列表获取成功, 数量:', banks.length, '总数:', totalItems, '是否有更多:', hasMoreData);
            } catch (error) {
                // console.error('获取题库列表失败:', error)
                commit('SET_BANKS', { banks: [], totalItems: 0 })
            } finally {
                commit('SET_LOADING', false)
            }
        },
        
        /**
         * 加载更多题库
         * @param {Object} commit - Vuex commit函数
         * @param {Object} state - Vuex状态对象
         * @returns {Promise<void>}
         */
        async fetchMoreBanks({commit, state}) {
            // 如果正在加载或没有更多数据，则不执行
            if (state.loading || !state.pagination.hasMoreData) {
                return;
            }
            
            commit('SET_LOADING', true);
            try {
                // 从API获取更多题库
                const { currentPage, pageSize } = state.pagination;
                
                // console.log('正在加载更多题库, 页码:', currentPage, '每页数量:', pageSize);
                
                const response = await getQuestionBankList({
                    page: currentPage,
                    pageSize: pageSize
                });
                
                // 追加题库列表
                const banks = response?.data?.data?.rows || [];
                const totalItems = response?.data?.data?.total || 0;
                
                // 追加数据而不是替换
                commit('APPEND_BANKS', { banks, totalItems });
                
                // 更新是否还有更多数据
                const hasMoreData = banks.length === pageSize && (currentPage * pageSize) < totalItems;
                commit('SET_PAGINATION', { hasMoreData });
                
                // console.log('加载更多题库成功, 新增数量:', banks.length, '总数:', totalItems, '是否有更多:', hasMoreData);
            } catch (error) {
                // console.error('加载更多题库失败:', error);
            } finally {
                commit('SET_LOADING', false);
            }
        },

        /**
         * 删除题库操作
         * @param {Object} context - Vuex上下文对象
         * @param {Function} context.commit - 提交mutation的方法
         * @param {Object} context.state - 当前状态
         * @param {number} bankId - 要删除的题库ID
         */
        async deleteBank({ commit, state, dispatch }, bankId) {
            commit('SET_LOADING', true);
            try {
                const res = await softDeleteQuestionBank(bankId);
                if (res.data.code === 200) {
                    // 1. 从本地状态中移除被删除的题库
                    commit('REMOVE_BANK', bankId);

                    // 2. 更新总记录数（减1）
                    const newTotal = state.pagination.totalItems - 1;

                    // 3. 计算是否需要调整页码
                    const itemsOnPage = state.banks.length;
                    const isLastItemOnPage = itemsOnPage === 0;
                    const isNotFirstPage = state.pagination.currentPage > 1;

                    if (isLastItemOnPage && isNotFirstPage) {
                        // 自动跳转到上一页
                        await dispatch('setPagination', {
                            currentPage: state.pagination.currentPage - 1,
                            totalItems: newTotal
                        });
                    } else {
                        // 只更新总数
                        commit('SET_PAGINATION', { totalItems: newTotal });
                    }

                    Vue.$message.success('题库删除成功');
                }
            } catch (error) {
                // console.error('删除失败', error);
                Vue.$message.error('删除题库失败');
            } finally {
                commit('SET_LOADING', false);
            }
        },

        /**
         * 设置分页信息
         * @param {Object} context - Vuex上下文对象
         * @param {Object} payload - 分页信息对象
         */
        setPagination({ commit, dispatch }, payload) {
            commit('SET_PAGINATION', payload);
            return dispatch('fetchBanks');
        },

        /**
         * 显示删除确认弹窗（供组件调用）
         * @param {Object} context - Vuex上下文对象
         * @param {Object} bank - 要删除的题库对象
         */
        showDeleteConfirm({ commit }, bank) {
            commit('SHOW_DELETE_CONFIRM', {
                title: '确认删除',
                message: `确定要删除这个题库【${bank.bankName}】吗？删除后所有关联题目也将被删除！`,
                target: bank
            })
        },

        /**
         * 确认删除操作（从弹窗调用）
         * @param {Object}  context - Vuex上下文对象
         */
        confirmDelete({commit, state, dispatch}) {
            const {target} = state.dialogs.deleteConfirm
            if (!target) return Promise.reject('没有可删除的目标')

            return dispatch('deleteBank', target.bankId)
                .then(() => {
                    commit('HIDE_DELETE_CONFIRM')
                    return  true
                })
                .catch(error => {
                    Vue.$message.error("删除题库失败")
                })
        },

        /**
         * 取消删除操作（从弹窗调用）
         * @param {Object} context - Vuex上下文对象
         */
        cancelDelete({ commit }) {
            commit('HIDE_DELETE_CONFIRM')
        },

        /************************题目相关**********************/

        /**
         * 获取题库下的题目列表
         * @param {Object} context - Vuex上下文对象
         * @param {Object} context.commit - 用于提交mutation的方法
         * @param {Object} context.state - 当前状态
         * @param {number} bankId - 题库ID
         */
        async fetchQuestions({commit, state: { questionPagination }}, bankId) {
            commit('SET_QUESTION_LOADING', true);
            try {
                // 封装参数 请求页码和每页条数封装
                const response = await getQuestionsByBank({
                    bankId,
                    page: questionPagination.currentPage,
                    pageSize: questionPagination.pageSize,
                });
                // console.log("获取题目列表成功:", response)
                // 更新题目列表
                commit('SET_QUESTIONS', {
                    questions: response?.data?.data?.rows || [],
                    totalItems: response?.data?.data?.total || 0
                    // 修复：删除bankId参数，防止刷新页面时题目数量翻倍
                });
            } catch (error) {
                // console.error('获取题目失败:', error);
                commit('SET_QUESTIONS', { 
                    questions: [], 
                    totalItems: 0
                    // 修复：也删除这里的bankId参数
                }); // 确保出错时也设置空数组
            } finally {
                commit('SET_QUESTION_LOADING', false);
            }
        },

        /**
         * 设置题目分页信息
         * @param {Object} context - Vuex上下文对象
         * @param {Object} payload - 分页信息对象
         */
        async setQuestionPagination({ commit, dispatch, state}, payload) {
            commit('SET_QUESTION_PAGINATION', payload)
            // 如果当前有题库，则重新获取题目列表
            if (state.currentBank) {
                await dispatch('fetchQuestions', state.currentBank.bankId)
            }
        },

        /**
         * 处理页码变化
         * @param {Object} context - Vuex上下文对象
         * @param {number} page - 新的页码
         */
        async handlePageChangeAction({dispatch}, page) {
            await dispatch('setQuestionPagination', { currentPage: page })
        },

        /**
         * 处理每页条数变化
         * @param {Object} context - Vuex上下文对象
         * @param {number} size - 新的每页条数
         */
        async handleSizeChangeAction({dispatch}, size) {
            await dispatch('setQuestionPagination', { pageSize: size, currentPage: 1})
        },

        /**
         * 切换题目的展开状态
         * @param {Object} - commit - Vuex上下文对象
         * @param {Number} - index - 要切换的题目的索引
         */
        toggleQuestionExpand({commit}, index) {
            commit('TOGGLE_QUESTION_EXPAND', index)
        },

        /**
         * 批量切换所有题目的展开状态
         * @param {Object} - commit - Vuex上下文对象
         */
        toggleAllQuestionsExpand({commit}) {
            commit('TOGGLE_ALL_QUESTIONS_EXPAND')
        },


        /**
         * 保存题目
         * @param {Object} context - Vuex上下文对象
         * @param {Object} questionData - 要保存的题目数据
         */
        async saveQuestion({ commit, state, dispatch }, questionData) {
            commit('SET_QUESTION_LOADING', true);

            try {
                // 1. 准备数据
                const formattedData = {
                    ...questionData,
                    id: questionData.id || questionData.questionId,
                    options: ['0', '1'].includes(questionData.type)
                        ? JSON.stringify(questionData.options.filter(opt => opt.text.trim()).map(opt => opt.text))
                        : '[]',
                    correctAnswer: formatCorrectAnswer(questionData)
                };

                // 2. 直接调用API保存
                const response = await updateQuestion(formattedData);

                if (response.data.code === 200) {
                    const updatedQuestion = response.data.data;

                    // 3. 更新Vuex中的题目列表
                    if (state.currentBank) {
                        const index = state.questions.findIndex(q => q.questionId === updatedQuestion.questionId);
                        if (index !== -1) {
                            commit('UPDATE_QUESTION', {
                                index,
                                question: updatedQuestion
                            });
                        } else {
                            commit('ADD_QUESTION', updatedQuestion);
                        }
                    }

                    return { success: true, data: updatedQuestion };
                } else {
                    throw new Error(response.data.message || '保存失败');
                }
            } catch (error) {
                // console.error('保存题目失败:', error);
                Vue.$message.error(error.message || '保存题目失败');
                throw error;
            } finally {
                commit('SET_QUESTION_LOADING', false);
            }
        },

        /**
         * 删除题目
         * @param {Object} context - Vuex上下文对象
         * @param {number} questionId - 要删除的题目的ID
         */
        async atDeleteQuestion({commit, state, dispatch}, questionId) {
            commit('SET_QUESTION_LOADING', true);

            try {
                // 先找到要删除的题目
                const question = state.questions.find(q => q.questionId === questionId);
                if (!question) {
                    throw new Error('未找到要删除的题目');
                }

                const response = await softDeleteQuestion({
                    questionId,
                    bankId: question.bankId
                });

                if (response.data.code === 200) {
                    // 1. 先获取删除前的题目总数
                    const oldTotal = state.questionPagination.totalItems;

                    // 2. 从questions数组中移除题目（但不修改totalItems）
                    commit('DELETE_QUESTION', questionId); // 新增的mutation

                    // 3. 统一更新总题数（只减1）
                    commit('SET_QUESTION_PAGINATION', {
                        totalItems: oldTotal - 1
                    });

                    // 4. 更新题库题目数量
                    commit('DECREMENT_BANK_QUESTION_COUNT', question.bankId);

                    // 检查是否需要调整分页
                    const itemsOnPage = state.questions.length;
                    const isLastItemOnPage = itemsOnPage === 0;
                    const isNotFirstPage = state.questionPagination.currentPage > 1;

                    if (isLastItemOnPage && isNotFirstPage) {
                        await dispatch('setQuestionPagination', {
                            currentPage: state.questionPagination.currentPage - 1
                        });
                    }

                    return true;
                }
                throw new Error(response.data.message || '删除失败');
            } catch (error) {
                // console.error('删除题目失败:', error);
                Vue.$message.error(error.message || '删除题目失败');
                throw error;
            } finally {
                commit('SET_QUESTION_LOADING', false);
            }
        }
    },
}
